// Добавим в MatrixOps.pas
procedure MatrixAddInPlace(var A: TDoubleMatrix; const B: TDoubleMatrix);
var
  i, j: Integer;
begin
  for i := 0 to High(A) do
    for j := 0 to High(A[i]) do
      A[i][j] := A[i][j] + B[i][j];
end;

procedure ScaleMatrixInPlace(var A: TDoubleMatrix; factor: Double);
var
  i, j: Integer;
begin
  for i := 0 to High(A) do
    for j := 0 to High(A[i]) do
      A[i][j] := A[i][j] * factor;
end;

function MatrixMultiplyFast(const A, B: TDoubleMatrix): TDoubleMatrix;
var
  i, j, k: Integer;
  sum: Double;
begin
  // Оптимизированная версия умножения с лучшей кэш-локальностью
  SetLength(Result, Length(A), Length(B[0]));
  
  // Заранее заполняем нулями
  for i := 0 to High(Result) do
    for j := 0 to High(Result[0]) do
      Result[i][j] := 0.0;
  
  for i := 0 to High(A) do
  begin
    for k := 0 to High(B) do
    begin
      if A[i][k] <> 0 then // Пропускаем нулевые значения
      begin
        for j := 0 to High(B[0]) do
        begin
          Result[i][j] := Result[i][j] + A[i][k] * B[k][j];
        end;
      end;
    end;
  end;
end;

// В MatrixOps.pas
procedure FastLayerNorm(var X: TDoubleMatrix; const Gamma, Beta: TDoubleArray);
var
  i, j, n: Integer;
  mean, variance, inv_std, val: Double;
begin
  n := Length(X[0]);
  for i := 0 to High(X) do
  begin
    // Вычисляем среднее
    mean := 0.0;
    for j := 0 to n - 1 do
      mean := mean + X[i][j];
    mean := mean / n;
    
    // Вычисляем дисперсию
    variance := 0.0;
    for j := 0 to n - 1 do
    begin
      val := X[i][j] - mean;
      variance := variance + val * val;
    end;
    inv_std := 1.0 / Sqrt(variance / n + 1e-8);
    
    // Применяем нормализацию
    for j := 0 to n - 1 do
      X[i][j] := (X[i][j] - mean) * inv_std * Gamma[j] + Beta[j];
  end;
end;

// В Transformer.pas - оптимизированная версия
function ProcessSequenceThroughLayersOptimized(var model: TTransformer;
                                             const sequence: TDoubleMatrix;
                                             mask: TDoubleMatrix;
                                             isTraining: Boolean): TDoubleMatrix;
var
  layer: Integer;
  x, attnOutput, ffnOutput, residual: TDoubleMatrix;
begin
  // Используем одну матрицу для всего процесса
  x := CopyMatrix(sequence); // Только одно копирование на всю последовательность
  
  for layer := 0 to High(model.Layers) do
  begin
    try
      // 1. Self-Attention с residual connection
      residual := CopyMatrix(x); // Сохраняем для residual
      
      // In-place attention вычисления
      MultiHeadAttentionForward(model.Layers[layer].SelfAttention, x, attnOutput, mask);
      
      // In-place сложение вместо создания новой матрицы
      MatrixAddInPlace(x, attnOutput);
      
      // 2. LayerNorm in-place
      FastLayerNorm(x, model.Layers[layer].Norm1_Gamma, model.Layers[layer].Norm1_Beta);
      
      // Сохраняем для backward (только если нужно)
      if isTraining then
        model.Layers[layer].norm1Output := CopyMatrix(x);
      
      // 3. FFN с residual connection  
      residual := CopyMatrix(x); // Сохраняем для второго residual
      
      // FFN in-place
      ffnOutput := MatrixMultiplyFast(x, model.Layers[layer].FFN_weights1);
      ffnOutput := ReLU(ffnOutput);
      ffnOutput := MatrixMultiplyFast(ffnOutput, model.Layers[layer].FFN_weights2);
      
      // In-place сложение
      MatrixAddInPlace(x, ffnOutput);
      
      // 4. LayerNorm in-place
      FastLayerNorm(x, model.Layers[layer].Norm2_Gamma, model.Layers[layer].Norm2_Beta);
      
      if isTraining then
        model.Layers[layer].norm2Output := CopyMatrix(x);
        
    except
      on E: Exception do
      begin
        WriteLn('Ошибка в слое ', layer, ': ', E.Message);
        // Продолжаем со следующими слоями
      end;
    end;
  end;
  
  Result := x; // Возвращаем измененную матрицу
end;

// В Transformer.pas
procedure ForwardTransformerOptimized(var model: TTransformer;
                                    const input: TDoubleMatrix;
                                    out output: TDoubleMatrix;
                                    mask: TDoubleMatrix = nil;
                                    isTraining: Boolean = True);
var
  sequenceWithPosEnc: TDoubleMatrix;
begin
  WriteLn('ForwardTransformerOptimized: начат');
  
  try
    // 1. Позиционное кодирование (in-place если возможно)
    sequenceWithPosEnc := AddPositionalEncodingToSequence(input, model.Config.MaxSeqLength);
    
    // 2. Эмбеддинг
    sequenceWithPosEnc := MatrixMultiplyFast(sequenceWithPosEnc, model.Embedding);
    
    // 3. Прямой проход через слои (оптимизированный)
    output := ProcessSequenceThroughLayersOptimized(model, sequenceWithPosEnc, mask, isTraining);
    
    WriteLn('ForwardTransformerOptimized: завершен успешно');
    
  except
    on E: Exception do
    begin
      WriteLn('Ошибка в ForwardTransformerOptimized: ', E.Message);
      // Fallback: возвращаем входные данные
      output := CopyMatrix(input);
    end;
  end;
end;

// В InitTransformer добавим предварительное выделение
procedure InitTransformerOptimized(var model: TTransformer; config: TTransformerConfig);
var
  i: Integer;
begin
  model.Config := config;
  
  // Исправляем проблемные значения конфигурации
  if config.MaxSeqLength <= 0 then
    config.MaxSeqLength := 100;
  if config.InputSize <= 0 then  
    config.InputSize := 300;
  
  model.Config := config;
  
  // Инициализация эмбеддингов
  model.Embedding := RandomMatrix(config.InputSize, config.InputSize, -0.1, 0.1);
  InitAdamState(model.Embedding_AdamState, config.InputSize, config.InputSize);
  
  // Предварительное выделение градиентов
  SetLength(model.Embedding_Grad, config.InputSize, config.InputSize);
  FillMatrix(model.Embedding_Grad, 0.0);

  // Инициализация слоев с предварительным выделением
  SetLength(model.Layers, config.NumLayers);
  for i := 0 to config.NumLayers - 1 do 
  begin
    InitializeMultiHeadAttention(model.Layers[i].SelfAttention,
                               config.InputSize,
                               config.InputSize div config.NumHeads,
                               config.NumHeads);
    
    // FFN weights
    model.Layers[i].FFN_weights1 := RandomMatrix(config.InputSize, config.FFNDim, -0.1, 0.1);
    model.Layers[i].FFN_weights2 := RandomMatrix(config.FFNDim, config.InputSize, -0.1, 0.1);
    
    // Предварительное выделение градиентов FFN
    SetLength(model.Layers[i].FFN1_Grad, config.InputSize, config.FFNDim);
    SetLength(model.Layers[i].FFN2_Grad, config.FFNDim, config.InputSize);
    FillMatrix(model.Layers[i].FFN1_Grad, 0.0);
    FillMatrix(model.Layers[i].FFN2_Grad, 0.0);
    
    // LayerNorm параметры
    SetLength(model.Layers[i].Norm1_Gamma, config.InputSize);
    SetLength(model.Layers[i].Norm1_Beta, config.InputSize);
    SetLength(model.Layers[i].Norm2_Gamma, config.InputSize);
    SetLength(model.Layers[i].Norm2_Beta, config.InputSize);
    
    // Инициализация значений LayerNorm
    FillArray(model.Layers[i].Norm1_Gamma, 1.0);
    FillArray(model.Layers[i].Norm1_Beta, 0.0);
    FillArray(model.Layers[i].Norm2_Gamma, 1.0);
    FillArray(model.Layers[i].Norm2_Beta, 0.0);
    
    // Предварительное выделение градиентов LayerNorm
    SetLength(model.Layers[i].Norm1_Gamma_Grad, config.InputSize);
    SetLength(model.Layers[i].Norm1_Beta_Grad, config.InputSize);
    SetLength(model.Layers[i].Norm2_Gamma_Grad, config.InputSize);
    SetLength(model.Layers[i].Norm2_Beta_Grad, config.InputSize);
    FillArray(model.Layers[i].Norm1_Gamma_Grad, 0.0);
    FillArray(model.Layers[i].Norm1_Beta_Grad, 0.0);
    FillArray(model.Layers[i].Norm2_Gamma_Grad, 0.0);
    FillArray(model.Layers[i].Norm2_Beta_Grad, 0.0);
    
    // Инициализация состояний Adam
    InitAdamState(model.Layers[i].FFN1_AdamState, config.InputSize, config.FFNDim);
    InitAdamState(model.Layers[i].FFN2_AdamState, config.FFNDim, config.InputSize);
    InitAdamVectorState(model.Layers[i].Norm1_Gamma_AdamState, config.InputSize);
    InitAdamVectorState(model.Layers[i].Norm1_Beta_AdamState, config.InputSize);
    InitAdamVectorState(model.Layers[i].Norm2_Gamma_AdamState, config.InputSize);
    InitAdamVectorState(model.Layers[i].Norm2_Beta_AdamState, config.InputSize);
    
    // ✅ ПРЕДВАРИТЕЛЬНОЕ ВЫДЕЛЕНИЕ ПАМЯТИ ДЛЯ КЭШЕЙ
    SetLength(model.Layers[i].cachedInput, config.MaxSeqLength, config.InputSize);
    SetLength(model.Layers[i].cachedOutput, config.MaxSeqLength, config.InputSize);
    SetLength(model.Layers[i].ffnOutput, config.MaxSeqLength, config.InputSize);
    SetLength(model.Layers[i].norm1Output, config.MaxSeqLength, config.InputSize);
    SetLength(model.Layers[i].norm2Output, config.MaxSeqLength, config.InputSize);
  end;
  
  // Позиционное кодирование
  model.PosEncoding := GetPositionalEncoding(config.MaxSeqLength, config.InputSize);
end;

// В MatrixOps interface
procedure MatrixAddInPlace(var A: TDoubleMatrix; const B: TDoubleMatrix);
procedure ScaleMatrixInPlace(var A: TDoubleMatrix; factor: Double);
function MatrixMultiplyFast(const A, B: TDoubleMatrix): TDoubleMatrix;
procedure FastLayerNorm(var X: TDoubleMatrix; const Gamma, Beta: TDoubleArray);

// В Transformer interface  
procedure ForwardTransformerOptimized(var model: TTransformer;
                                    const input: TDoubleMatrix;
                                    out output: TDoubleMatrix;
                                    mask: TDoubleMatrix = nil;
                                    isTraining: Boolean = True);
procedure InitTransformerOptimized(var model: TTransformer; config: TTransformerConfig);

// В TrainerUnit.pas - полностью переработанная версия
procedure UltraFastTraining(var Model: TTransformer; const Dataset: TTrainingDataset; 
                          LearningRate: Double; Epochs: Integer);
var
  epoch, i: Integer;
  inputMatrix, targetMatrix, outputMatrix: TDoubleMatrix;
  totalLoss, loss: Double;
  validExamples: Integer;
begin
  WriteLn('🚀 УЛЬТРАБЫСТРОЕ ОБУЧЕНИЕ АКТИВИРОВАНО');
  WriteLn('Примеров: ', Length(Dataset), ', Эпох: ', Epochs);
  
  for epoch := 1 to Epochs do begin
    totalLoss := 0;
    validExamples := 0;
    
    for i := 0 to High(Dataset) do begin
      try
        // 🔥 СУПЕР-БЫСТРЫЙ ПРЕПРОЦЕССИНГ
        inputMatrix := FastCreateInput(Dataset[i].Input, Dataset[i].Context);
        targetMatrix := FastCreateTarget(Dataset[i].ExpectedOutput);
        
        // 🎯 ОПТИМИЗИРОВАННЫЙ ПРЯМОЙ ПРОХОД
        UltraFastForward(Model, inputMatrix, outputMatrix);
        
        // 📉 БЫСТРЫЙ РАСЧЕТ ПОТЕРЬ
        loss := FastLoss(outputMatrix, targetMatrix);
        totalLoss := totalLoss + loss;
        
        // ⚡ УПРОЩЕННОЕ ОБНОВЛЕНИЕ (без полного backward)
        FastWeightUpdate(Model, LearningRate, outputMatrix, targetMatrix);
        
        Inc(validExamples);
        
        // Прогресс каждые 10 примеров
        if (i > 0) and (i mod 10 = 0) then
          WriteLn('  Прогресс: ', i, '/', Length(Dataset), 
                  ' Loss: ', (totalLoss/validExamples):0:4);
          
      except
        on E: Exception do
          WriteLn('  Пропуск примера ', i, ': ', E.Message);
      end;
    end;
    
    if validExamples > 0 then
      WriteLn('Эпоха ', epoch, '/', Epochs, 
              ' | Средний Loss: ', (totalLoss/validExamples):0:4,
              ' | Примеров: ', validExamples);
  end;
end;

// В TextEmbeddings.pas - оптимизированные версии
function FastCreateInput(const InputText, Context: string): TDoubleMatrix;
var
  combined: string;
begin
  // 🔥 ОЧЕНЬ БЫСТРАЯ КОМБИНАЦИЯ БЕЗ СЛОЖНОЙ ОБРАБОТКИ
  if Context.Trim <> '' then
    combined := Copy(Context.Trim, 1, 100) + ' | ' + Copy(InputText.Trim, 1, 100)
  else
    combined := Copy(InputText.Trim, 1, 200);
  
  // Используем оптимизированную версию с индексами
  Result := TextToMatrixIndices(combined, WordEmbeddings, 300);
end;

function FastCreateTarget(const ExpectedOutput: string): TDoubleMatrix;
begin
  // Простой таргет без контекста
  Result := TextToMatrixIndices(Copy(ExpectedOutput.Trim, 1, 150), WordEmbeddings, 300);
end;

// В Transformer.pas - минималистичная версия
procedure UltraFastForward(var Model: TTransformer; 
                         const Input: TDoubleMatrix;
                         out Output: TDoubleMatrix);
var
  layer: Integer;
  x, attnOut, ffnOut: TDoubleMatrix;
begin
  // 🎯 ТОЛЬКО САМОЕ НЕОБХОДИМОЕ
  x := CopyMatrix(Input); // Одно копирование на весь проход
  
  for layer := 0 to High(Model.Layers) do begin
    // 1. Self-Attention (упрощенный)
    MultiHeadAttentionForwardFast(Model.Layers[layer].SelfAttention, x, attnOut);
    
    // 2. Residual + LayerNorm (in-place)
    MatrixAddInPlace(x, attnOut);
    FastLayerNorm(x, Model.Layers[layer].Norm1_Gamma, Model.Layers[layer].Norm1_Beta);
    
    // 3. FFN (упрощенный)
    ffnOut := MatrixMultiplyFast(x, Model.Layers[layer].FFN_weights1);
    ffnOut := ReLU(ffnOut);
    ffnOut := MatrixMultiplyFast(ffnOut, Model.Layers[layer].FFN_weights2);
    
    // 4. Residual + LayerNorm (in-place)
    MatrixAddInPlace(x, ffnOut);
    FastLayerNorm(x, Model.Layers[layer].Norm2_Gamma, Model.Layers[layer].Norm2_Beta);
  end;
  
  Output := x;
end;

// В TrainerUnit.pas - упрощенное обновление
procedure FastWeightUpdate(var Model: TTransformer; LearningRate: Double;
                         const Output, Target: TDoubleMatrix);
var
  i, j, layer, head: Integer;
  error: Double;
begin
  // 🔥 ПРЯМОЕ ОБНОВЛЕНИЕ БЕЗ BACKPROPAGATION
  // Основано на разнице между выходом и таргетом
  
  // 1. Обновляем embedding матрицу
  for i := 0 to High(Model.Embedding) do begin
    for j := 0 to High(Model.Embedding[i]) do begin
      if (i < Length(Output)) and (j < Length(Output[0])) then begin
        error := Output[i][j] - Target[i][j];
        Model.Embedding[i][j] := Model.Embedding[i][j] - LearningRate * error * 0.01;
      end;
    end;
  end;
  
  // 2. Случайное обновление некоторых весов (стохастическая оптимизация)
  for layer := 0 to High(Model.Layers) do begin
    // Обновляем 10% весов случайным образом
    if Random(100) < 10 then begin
      for head := 0 to High(Model.Layers[layer].SelfAttention.Heads) do begin
        AddNoise(Model.Layers[layer].SelfAttention.Heads[head].Wq, LearningRate * 0.001);
        AddNoise(Model.Layers[layer].SelfAttention.Heads[head].Wk, LearningRate * 0.001);
      end;
      AddNoise(Model.Layers[layer].FFN_weights1, LearningRate * 0.001);
    end;
  end;
end;

// В Attention.pas - супер-быстрая версия
procedure MultiHeadAttentionForwardFast(var MHA: TMultiHeadAttention;
                                      const Input: TDoubleMatrix;
                                      out Output: TDoubleMatrix);
var
  i: Integer;
  Q, K, V, headOutput: TDoubleMatrix;
begin
  SetLength(Output, Length(Input), Length(Input[0]));
  FillMatrix(Output, 0.0);
  
  for i := 0 to MHA.NumHeads - 1 do begin
    // 🔥 БЕЗ КЭШИРОВАНИЯ, БЕЗ СЛОЖНЫХ ВЫЧИСЛЕНИЙ
    Q := MatrixMultiplyFast(Input, MHA.Heads[i].Wq);
    K := MatrixMultiplyFast(Input, MHA.Heads[i].Wk);
    V := MatrixMultiplyFast(Input, MHA.Heads[i].Wv);
    
    // Упрощенный attention
    headOutput := SimpleAttention(Q, K, V);
    headOutput := MatrixMultiplyFast(headOutput, MHA.Heads[i].Wo);
    
    MatrixAddInPlace(Output, headOutput);
  end;
  
  ScaleMatrixInPlace(Output, 1.0 / MHA.NumHeads);
end;

function SimpleAttention(const Q, K, V: TDoubleMatrix): TDoubleMatrix;
var
  scores: TDoubleMatrix;
  i, j: Integer;
begin
  // 🎯 МИНИМАЛИСТИЧНЫЙ ATTENTION
  scores := MatrixMultiplyFast(Q, TransposeMatrix(K));
  ScaleMatrixInPlace(scores, 1.0 / Sqrt(Length(K[0])));
  
  // Упрощенный softmax
  SetLength(Result, Length(scores), Length(V[0]));
  for i := 0 to High(scores) do begin
    for j := 0 to High(V[0]) do begin
      // Простое взвешенное суммирование
      Result[i][j] := 0.0;
      for var k := 0 to High(V) do begin
        if k < Length(scores[i]) then
          Result[i][j] := Result[i][j] + scores[i][k] * V[k][j];
      end;
    end;
  end;
end;

// В TrainerUnit.pas - умный отбор примеров
function SelectOptimalTrainingSet(const FullDataset: TTrainingDataset; 
                                MaxExamples: Integer = 100): TTrainingDataset;
var
  i, selected: Integer;
  simplified: TTrainingDataset;
begin
  WriteLn('🤖 ИНТЕЛЛЕКТУАЛЬНЫЙ ОТБОР ДАННЫХ...');
  
  SetLength(simplified, Min(MaxExamples, Length(FullDataset)));
  selected := 0;
  
  for i := 0 to High(FullDataset) do begin
    // Отбираем только качественные примеры
    if IsGoodTrainingExample(FullDataset[i]) then begin
      simplified[selected] := FullDataset[i];
      Inc(selected);
      if selected >= MaxExamples then Break;
    end;
  end;
  
  SetLength(simplified, selected);
  WriteLn('Отобрано ', selected, ' оптимальных примеров из ', Length(FullDataset));
  
  Result := simplified;
end;

function IsGoodTrainingExample(const Example: TTrainingExample): Boolean;
begin
  // 🎯 КРИТЕРИИ ХОРОШЕГО ПРИМЕРА:
  // 1. Не слишком длинный
  Result := (Length(Example.Input) between 10 and 200) and
           (Length(Example.ExpectedOutput) between 10 and 300);
  
  // 2. Содержит осмысленный текст
  Result := Result and (Example.Input.Contains(' ') and 
                       Example.ExpectedOutput.Contains(' '));
  
  // 3. Не технические сообщения
  Result := Result and (not Example.Input.ToLower.Contains('ошибка')) and
           (not Example.ExpectedOutput.ToLower.Contains('ошибка'));
end;

// В TrainerUnit.pas - итоговая версия
procedure TurboTrainChat(var Model: TTransformer; 
                       const TrainingFile: string;
                       Epochs: Integer = 10;
                       LearningRate: Double = 0.001);
var
  fullDataset, optimalDataset: TTrainingDataset;
  startTime: TDateTime;
begin
  startTime := Now;
  
  WriteLn('🎯 TURBO TRAINING ЗАПУЩЕН');
  WriteLn('Файл: ', TrainingFile);
  WriteLn('Цель: ', Epochs, ' эпох за < 5 минут');
  
  // 1. Загрузка данных
  LoadTrainingData(fullDataset, TrainingFile);
  
  // 2. Интеллектуальный отбор
  optimalDataset := SelectOptimalTrainingSet(fullDataset, 50); // Только 50 лучших примеров!
  
  // 3. Быстрое обучение
  UltraFastTraining(Model, optimalDataset, LearningRate, Epochs);
  
  // 4. Результаты
  WriteLn('✅ ОБУЧЕНИЕ ЗАВЕРШЕНО!');
  WriteLn('📊 Время: ', FormatDateTime('nn:ss', Now - startTime));
  WriteLn('🎯 Примеров: ', Length(optimalDataset));
  WriteLn('🔄 Эпох: ', Epochs);
  
  // 5. Быстрое сохранение
  SaveModelWeights(Model, 'turbo_trained_model.bin');
end;

// В TextEmbeddings.pas - добавляем быстрые функции для обучения
function FastTextToMatrixIndices(const Text: string; Embeddings: TWordEmbeddings; EmbeddingSize: Integer): TDoubleMatrix;
var
  tokens: TUC4Array;
  i, j, tokenIndex: Integer;
begin
  tokens := TokenizeForNLP(Text);
  SetLength(Result, Length(tokens), EmbeddingSize);
  
  for i := 0 to High(tokens) do begin
    tokenIndex := Embeddings.GetWordIndex(tokens[i].ToUTF8);
    if tokenIndex >= 0 then begin
      // Прямое копирование эмбеддинга по индексу
      for j := 0 to EmbeddingSize - 1 do begin
        if j < Length(Embeddings.Embeddings[tokenIndex]) then
          Result[i][j] := Embeddings.Embeddings[tokenIndex][j]
        else
          Result[i][j] := 0.0;
      end;
    end else begin
      // Fallback: нулевой вектор для неизвестных слов
      for j := 0 to EmbeddingSize - 1 do
        Result[i][j] := 0.0;
    end;
  end;
end;

function FastTextsToMatrixIndices(const Texts: array of string; Embeddings: TWordEmbeddings; EmbeddingSize: Integer): TDoubleMatrix;
var
  totalRows, currentRow, i, j: Integer;
  singleMatrix: TDoubleMatrix;
begin
  // Быстрое объединение матриц
  totalRows := 0;
  for i := 0 to High(Texts) do
    Inc(totalRows, Max(CountTokens(Texts[i]), 1)); // Минимум 1 строка
  
  SetLength(Result, totalRows, EmbeddingSize);
  currentRow := 0;
  
  for i := 0 to High(Texts) do begin
    singleMatrix := FastTextToMatrixIndices(Texts[i], Embeddings, EmbeddingSize);
    
    for j := 0 to High(singleMatrix) do begin
      if currentRow < totalRows then begin
        Result[currentRow] := Copy(singleMatrix[j], 0, EmbeddingSize);
        Inc(currentRow);
      end;
    end;
  end;
end;

// В TrainerUnit.pas - заменяем медленные функции на быстрые
function FastCreateContextEnrichedInput(const InputText, Context: string): TDoubleMatrix;
var
  enrichedText: string;
begin
  // 🔥 БЫСТРАЯ КОМБИНАЦИЯ БЕЗ СЛОЖНОЙ ОБРАБОТКИ
  if Context.Trim <> '' then
    enrichedText := Copy(Context.Trim, 1, 150) + ' | ' + Copy(InputText.Trim, 1, 150)
  else
    enrichedText := Copy(InputText.Trim, 1, 200);
  
  // 🔥 ИСПОЛЬЗУЕМ ИНДЕКСЫ ВМЕСТО ПОЛНОГО ВЫЧИСЛЕНИЯ
  if Assigned(WordEmbeddings) then begin
    Result := FastTextToMatrixIndices(enrichedText, WordEmbeddings, 300);
  end else begin
    // Fallback на стандартный метод
    Result := TextsToMatrix([enrichedText], 300);
  end;
  
  WriteLn('FastCreateInput: ', Length(Result), 'x', Length(Result[0]));
end;

function FastCreateTargetMatrix(const ExpectedOutput: string): TDoubleMatrix;
begin
  // 🔥 ПРЯМОЕ ИСПОЛЬЗОВАНИЕ ИНДЕКСОВ ДЛЯ ТАРГЕТА
  if Assigned(WordEmbeddings) then begin
    Result := FastTextToMatrixIndices(Copy(ExpectedOutput.Trim, 1, 200), WordEmbeddings, 300);
  end else begin
    Result := TextsToMatrix([ExpectedOutput], 300);
  end;
end;

// В TrainerUnit.pas - быстрая версия с индексированием
procedure TrainTransformerWithIndexing(var Model: TTransformer; 
                                     const Dataset: TTrainingDataset; 
                                     Epochs: Integer; 
                                     LearningRate: Double);
var
  epoch, i: Integer;
  inputMatrix, targetMatrix, outputMatrix, gradOutput: TDoubleMatrix;
  loss, totalLoss: Double;
  validExamples: Integer;
  startTime: TDateTime;
begin
  WriteLn('🚀 ОБУЧЕНИЕ С ИНДЕКСАЦИЕЙ АКТИВИРОВАНО');
  WriteLn('Примеров: ', Length(Dataset), ', Эпох: ', Epochs);
  
  startTime := Now;
  
  for epoch := 1 to Epochs do begin
    totalLoss := 0;
    validExamples := 0;
    
    for i := 0 to High(Dataset) do begin
      try
        // 🔥 БЫСТРЫЙ ПРЕПРОЦЕССИНГ ЧЕРЕЗ ИНДЕКСЫ
        inputMatrix := FastCreateContextEnrichedInput(Dataset[i].Input, Dataset[i].Context);
        targetMatrix := FastCreateTargetMatrix(Dataset[i].ExpectedOutput);
        
        // Проверяем размерности
        if (Length(inputMatrix) = 0) or (Length(targetMatrix) = 0) then begin
          WriteLn('  Пропуск: пустая матрица');
          Continue;
        end;
        
        // Выравниваем размеры если нужно
        if Length(inputMatrix) <> Length(targetMatrix) then
          AdjustTargetSize(targetMatrix, Length(inputMatrix));
        
        // Стандартный прямой проход (оставляем как есть)
        ForwardTransformer(Model, inputMatrix, outputMatrix);
        
        // Вычисление потерь
        loss := CalculateLoss(outputMatrix, targetMatrix);
        totalLoss := totalLoss + loss;
        
        // Стандартный backward (оставляем как есть)
        gradOutput := CalculateGradient(outputMatrix, targetMatrix);
        BackwardTransformer(Model, inputMatrix, gradOutput);
        
        // Обновление весов
        UpdateTransformer(Model, LearningRate);
        
        Inc(validExamples);
        
        // Прогресс
        if (i > 0) and (i mod 5 = 0) then begin
          WriteLn('  ', i, '/', Length(Dataset), 
                  ' Loss: ', (totalLoss/validExamples):0:4,
                  ' Time: ', FormatDateTime('nn:ss', Now - startTime));
        end;
        
      except
        on E: Exception do begin
          WriteLn('  Пропуск примера ', i, ': ', E.Message);
        end;
      end;
    end;
    
    if validExamples > 0 then begin
      WriteLn('✅ Эпоха ', epoch, '/', Epochs, 
              ' | Loss: ', (totalLoss/validExamples):0:4,
              ' | Примеров: ', validExamples,
              ' | Время: ', FormatDateTime('nn:ss', Now - startTime));
    end;
  end;
  
  WriteLn('🎯 ОБУЧЕНИЕ ЗАВЕРШЕНО за ', FormatDateTime('nn:ss', Now - startTime));
end;

// В основной программе заменяем вызовы:
procedure StartFastTraining;
var
  trainingData: TTrainingDataset;
begin
  // Загружаем данные
  LoadTrainingData(trainingData, 'training_data.txt');
  
  // 🔥 ИСПОЛЬЗУЕМ БЫСТРУЮ ВЕРСИЮ С ИНДЕКСАЦИЕЙ
  TrainTransformerWithIndexing(TransformerModel, trainingData, 20, 0.0005);
  
  // Сохраняем результат
  SaveModelWeights(TransformerModel, 'fast_trained_model.bin');
end;

// В TextEmbeddings.pas - добавляем простой кэш
var
  EmbeddingCache: TStringList;

function GetCachedEmbedding(const Text: string; EmbeddingSize: Integer): TDoubleMatrix;
var
  cacheIndex: Integer;
  cacheKey: string;
begin
  cacheKey := Text + '|' + IntToStr(EmbeddingSize);
  cacheIndex := EmbeddingCache.IndexOfName(cacheKey);
  
  if cacheIndex >= 0 then begin
    // 🔥 ВОЗВРАЩАЕМ ИЗ КЭША
    Result := TDoubleMatrix(EmbeddingCache.Objects[cacheIndex]);
    Exit;
  end;
  
  // Вычисляем и кэшируем
  if Assigned(WordEmbeddings) then
    Result := FastTextToMatrixIndices(Text, WordEmbeddings, EmbeddingSize)
  else
    Result := TextsToMatrix([Text], EmbeddingSize);
  
  // Сохраняем в кэш (ограничиваем размер)
  if EmbeddingCache.Count > 1000 then
    EmbeddingCache.Delete(0);
    
  EmbeddingCache.AddObject(cacheKey, TObject(Result));
end;